The present invention is generally directed to the control of computers, such as personal computers, from remote sources, and more particularly to code module interfaces which enable a user to adjust the control functionality at run-time.
In one exemplary application, the present invention can be employed in the process of installing software onto a computer. There are a number of different ways in which software can be installed. For example, the software can be copied from diskettes that are inserted into the computer, or it can be downloaded from another source, such as an external disk drive, to which the computer is connected. In these approaches, the typical installation process involves booting the computer from the diskette or other source, and then having the computer install the software itself on an internal storage device, such as a hard disk drive.
While this approach to the installation of software is straightforward, it is limited by virtue of the fact that it is relatively slow. In particular, each computer is required to boot and launch its own installation application. In addition, the speed of transfer is dictated by the speed of the computer itself. In a manufacturing environment of the type where operating system software is installed on each newly manufactured computer, a slow software installation process can present a significant bottleneck in the overall manufacturing process.
It is desirable, therefore, to provide an approach which permits software to be installed on a computer at a faster rate. To this end, it is preferable to use a host controller, i.e., a higher speed computer, to control the software downloading process. In order that this approach to installing software be carried out most efficiently, the computer onto which the software is being installed should be in a passive state, insofar as initiating commands for the downloading of the software is concerned. In this regard, therefore, it is desirable to provide a mechanism which permits the computer to behave as if it is an external storage device under the control of the host controller.
Accordingly, in a related disclosure (U.S. patent application Ser. No. 08/383,863 entitled xe2x80x9cDevice Driver For Controlling A Computer From An External Sourcexe2x80x9d and filed on Feb. 6, 1995) a system for downloading software to remote computers is described. This system provides a downloading engine which can be run by a plurality of different users to download software. However, different users may have different requirements for the way in which software is downloaded to remote computers at this installation. For example, at one site, a process engineer may want to run a virus check prior to downloading software. At another site, the user may prefer a different type of interface than the standard interface supplied with the software that controls downloading from the host controller. At still a third site, the user may want to download both operating system software and bundled application software.
Thus, these end users tend to adjust the functionality of the downloading engine provided to them by the developer. Various techniques are known for adjusting the functionality of existing software. For example, so-called xe2x80x9cpatchesxe2x80x9d are frequently distributed to fix bugs in existing software. When run, a patch actually modifies the software code so that the change in functionality implemented by the patch is permanent in the sense that the new functionality is present every time that the software is run. Thus, patches have the drawback that the user is unable to selectively implement functionality changes, e.g., to selectively adjust the routine for downloading software to computers.
In the foregoing example relating to the downloaded engine, each user that desires different functionality for the downloading engine will typically create his or her own patch. As a result, the downloading engine itself will effectively mutate, i.e., each user may have a different version of the downloading engine. This creates additional problems including, for example, difficulty in upgrading existing software, parallel development wherein one or more users may be trying to add the same needed functionality to the downloading engine, and impairing the developer""s ability to replicate problems experienced by users.
Accordingly, it would be desirable to have techniques and mechanisms for allowing the functionality of software, e.g., control software for downloading from a host controller to one or more remote computers, to be adjusted at run-time to provide users with complete flexibility in the control software""s functionality while also allowing the control software developer to maintain control over the software code.
In accordance with the present invention, code module interfaces are provided which allow a user to adjust the functionality of a program which operates as a state machine at run-time. According to exemplary embodiments of the present invention, the code module interfaces (CMIs) can be selectively activated by a user at run-time. Then, the control software will call the CMIs at various instances, for example, at startup, after each state change in the control software, at idle time and when the control software has completed all of its tasks. Alternatively, when each CMI is loaded, it can specify at the state change(s) at which it is to be called to increase speed of operation.
A powerful feature of CMIs according to the present invention is their ability to change the operating state of the control software itself. That is, the CMI may be called at a point when the control software is about to transition from a first state to a second state. However, when finished running, the CMI may instead direct re-entry to the control software at some third state.
According to yet another feature of the present invention, the capability to create CMIs may be provided to the end-user of the controlled software. In this way, the end-user may create CMIs which adapt the downloading engine to his or her own specific needs. However, the end-user""s creation of, and implementation of, a particular CMI will not alter the characteristics or code of the downloading engine itself. Thus, from the control software developer""s point of view, CMIs according to the present invention allow end-users to adapt functionality to fit their own needs, but without raising problems related to version control, parallel development or problem replication.
Further features of the invention, and the advantages offered thereby, are explained in detail hereinafter with reference to exemplary embodiments illustrated in the accompanying drawings.